package com.zz.admin.subTableManagement.service.impl;

import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zz.admin.subTableManagement.dto.SubTableDto;
import com.zz.admin.subTableManagement.entity.SubTable;
import com.zz.admin.subTableManagement.mapper.SubTableMapper;
import com.zz.admin.subTableManagement.service.SubTableService;
import com.zz.common.base.dto.PageListResultDto;
import com.zz.common.base.enums.BaseExceptionEnum;
import com.zz.common.base.param.QueryParam;
import com.zz.common.constants.BaseConstant;
import com.zz.common.exception.ExceptionFactory;
import com.zz.common.utils.common.UUIDGenerator;
import com.zz.common.utils.mapper.BeanMapper;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

/**
 * 子 服务实现类
 *
 * @author zl
 * @since 2025-11-18 19:00:16
 */
@Service
@Slf4j
public class SubTableServiceImpl extends ServiceImpl<SubTableMapper, SubTable> implements SubTableService {

    @Resource
    private SubTableMapper subTableMapper;

    @Override
    public PageListResultDto<SubTableDto> queryWithPage(SubTableDto subTableDto, QueryParam queryParam) {
        Page<SubTable> page = new Page<>(queryParam.getPageNum(), queryParam.getPageSize());
        QueryWrapper<SubTable> wrapper = new QueryWrapper<>();
        wrapper.eq("del_flag", BaseConstant.NO);
        if (StringUtils.isNotBlank(subTableDto.getItemName())) {
            wrapper.like("item_name", "%" + subTableDto.getItemName() + "%");
        }
        if (StringUtils.isNotBlank(subTableDto.getItemValue())) {
            wrapper.eq("item_value", subTableDto.getItemValue());
        }
        page = subTableMapper.selectPage(page, wrapper);
        List<SubTable> subTables = subTableMapper.selectList(page, wrapper);
        List<SubTableDto> subTableDtos = BeanMapper.mapList(subTables, SubTable.class, SubTableDto.class);
        return new PageListResultDto<>((int) page.getCurrent(), (int) page.getTotal(), queryParam.getPageSize(), subTableDtos);
    }

    @Override
    public List<SubTableDto> queryWithNoPage(SubTableDto subTableDto) {
        QueryWrapper<SubTable> wrapper = new QueryWrapper<>();
        wrapper.eq("del_flag", BaseConstant.NO);
        List<SubTable> subTables = subTableMapper.selectList(wrapper);
        return BeanMapper.mapList(subTables, SubTable.class, SubTableDto.class);
    }

    @Override
    public SubTableDto queryById(String id) {
        if (StringUtils.isBlank(id)) {
            return null;
        }
        SubTable subTable = subTableMapper.selectById(id);
        if (subTable == null || BaseConstant.YES.equals(subTable.getDelFlag())) {
            return null;
        }
        return BeanMapper.map(subTable, SubTableDto.class);
    }


    @Override
    public List<SubTableDto> queryByIds(List<String> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return new ArrayList<>();
        }
        List<SubTable> subTables = subTableMapper.selectByIds(ids);
        if (CollectionUtils.isEmpty(subTables)) {
            return new ArrayList<>();
        }
        return BeanMapper.mapList(subTables, SubTable.class, SubTableDto.class);
    }

    @Override
    public List<SubTableDto> queryByParentId(String parentId) {
        if (StringUtils.isBlank(parentId)) {
            return new ArrayList<>();
        }
        QueryWrapper<SubTable> wrapper = new QueryWrapper<>();
        wrapper.eq("parent_id", parentId);
        wrapper.eq("del_flag", BaseConstant.NO);
        List<SubTable> subTables = subTableMapper.selectList(wrapper);
        if (CollectionUtils.isEmpty(subTables)) {
            return new ArrayList<>();
        }
        return BeanMapper.mapList(subTables, SubTable.class, SubTableDto.class);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public SubTableDto save(SubTableDto subTableDto) {
        // 根据业务修改
        return insert(subTableDto);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public List<SubTableDto> saveBatch(List<SubTableDto> subTableDtos) {
        // 根据业务修改
        return insertList(subTableDtos);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public SubTableDto modify(SubTableDto subTableDto) {
        // 根据业务修改
        updateById(subTableDto);
        return subTableDto;
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public List<SubTableDto> modifyBatch(List<SubTableDto> subTableDtos) {
        // 根据业务修改
        return updateList(subTableDtos);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public int trueDelete(String id) {
        SubTable entity = new SubTable();
        entity.setId(id);
        return subTableMapper.deleteById(id);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void delete(String id) {
        // 根据业务修改
        SubTableDto subTableDto = new SubTableDto();
        subTableDto.setId(id);
        deleteById(subTableDto);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void deleteBatch(List<String> ids) {
        // 根据业务修改
        deleteByIds(ids);
    }

    @Override
    public void deleteByParentId(String parentId) {
        if (StringUtils.isBlank(parentId)) {
            return;
        }
        QueryWrapper<SubTable> wrapper = new QueryWrapper<>();
        wrapper.eq("parent_id", parentId);
        wrapper.eq("del_flag", BaseConstant.NO);
        List<SubTable> list = subTableMapper.selectList(wrapper);
        if (CollectionUtils.isEmpty(list)) {
            return;
        }
        List<String> ids = new ArrayList<>();
        for (SubTable dto : list) {
            ids.add(dto.getId());
        }
        deleteByIds(ids);
    }

    @Override
    public void deleteByParentIds(List<String> parentIds) {
        if (CollectionUtils.isEmpty(parentIds)) {
            return;
        }
        QueryWrapper<SubTable> wrapper = new QueryWrapper<>();
        wrapper.in("parent_id", parentIds);
        wrapper.eq("del_flag", BaseConstant.NO);
        List<SubTable> list = subTableMapper.selectList(wrapper);
        if (CollectionUtils.isEmpty(list)) {
            return;
        }
        List<String> ids = new ArrayList<>();
        for (SubTable dto : list) {
            ids.add(dto.getId());
        }
        deleteByIds(ids);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public SubTableDto insert(SubTableDto subTableDto) {
        subTableDto.setId(UUIDGenerator.generateUUID());
        subTableDto.setDelFlag(BaseConstant.NO);
        SubTable entity = BeanMapper.map(subTableDto, SubTable. class);
        subTableMapper.insert(entity);
        return subTableDto;
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public SubTableDto insertWithId(SubTableDto subTableDto) {
        if (StringUtils.isBlank(subTableDto.getId())) {
            subTableDto.setId(UUIDGenerator.generateUUID());
        }
        subTableDto.setDelFlag(BaseConstant.NO);
        SubTable entity = BeanMapper.map(subTableDto, SubTable.class);
        subTableMapper.insert(entity);
        return subTableDto;
    }

    private List<SubTableDto> insertList(List<SubTableDto> subTableDtos) {
        if (CollectionUtils.isEmpty(subTableDtos)) {
            throw ExceptionFactory.createBaseException(BaseExceptionEnum.NOT_FOUND, "批量插入时，参数不能为空");
        }
        List<SubTable> insertList = new ArrayList<>();
        for (SubTableDto subTableDto : subTableDtos) {
            if (StringUtils.isBlank(subTableDto.getId())) {
                subTableDto.setId(UUIDGenerator.generateUUID());
            }
            subTableDto.setDelFlag(BaseConstant.NO);
            insertList.add(BeanMapper.map(subTableDto, SubTable.class));
        }
        subTableMapper.insert(insertList, 1000);
        return subTableDtos;
    }

    private List<SubTableDto> updateList(List<SubTableDto> subTableDtos) {
        if (CollectionUtils.isEmpty(subTableDtos)) {
            throw ExceptionFactory.createBaseException(BaseExceptionEnum.NOT_FOUND, "批量更新时，参数不能为空");
        }
        for (SubTableDto subTableDto : subTableDtos) {
            if (StringUtils.isBlank(subTableDto.getId())) {
                throw ExceptionFactory.createBaseException(BaseExceptionEnum.NOT_FOUND, "批量更新时，主键不能为空");
            }
        }
        List<SubTable> subTableList = BeanMapper.mapList(subTableDtos, SubTableDto.class, SubTable.class);
        subTableMapper.updateById(subTableList, 1000);
        return subTableDtos;
    }

    @Transactional(rollbackFor = Exception.class)
    public int updateById(SubTableDto subTableDto) {
        if (StringUtils.isBlank(subTableDto.getId())) {
            throw ExceptionFactory.createBaseException(BaseExceptionEnum.INTERNAL_SERVER_ERROR, "更新时，主键不能为空");
        }
        SubTable entity = BeanMapper.map(subTableDto, SubTable.class);
        return subTableMapper.updateById(entity);
    }

    @Transactional(rollbackFor = Exception.class)
    public int deleteById(SubTableDto subTableDto) {
        subTableDto.setDelFlag(BaseConstant.YES);
        return updateById(subTableDto);
    }
    
    @Transactional(rollbackFor = Exception.class)
    public void deleteByIds(List<String> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            throw ExceptionFactory.createBaseException(BaseExceptionEnum.NOT_FOUND, "批量删除时，参数不能为空");
        }
        for (String id : ids) {
            SubTableDto subTableDto = new SubTableDto();
            subTableDto.setId(id);
            subTableDto.setDelFlag(BaseConstant.YES);
            updateById(subTableDto);
        }
    }

}
